home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / winreg.py < prev    next >
Text File  |  2006-05-23  |  22KB  |  702 lines
  1. # Copyright (c) 2003-2006 CORE Security Technologies
  2. #
  3. # This software is provided under under a slightly modified version
  4. # of the Apache Software License. See the accompanying LICENSE file
  5. # for more information.
  6. #
  7. # $Id: winreg.py,v 1.7 2006/05/23 21:19:26 gera Exp $
  8. #
  9. # Description:
  10. #   WinReg (Windows Registry) interface implementation.
  11. #
  12.  
  13. import array
  14. import struct
  15.  
  16. import dcerpc
  17. from impacket import ImpactPacket
  18.  
  19. MSRPC_UUID_WINREG = '\x01\xd0\x8c\x33\x44\x22\xf1\x31\xaa\xaa\x90\x00\x38\x00\x10\x03\x01\x00\x00\x00'
  20.  
  21. # Registry Security Access Mask values
  22. KEY_CREATE_LINK         = 0x20
  23. KEY_CREATE_SUB_KEY      = 0x04
  24. KEY_ENUMERATE_SUB_KEYS  = 0x08
  25. KEY_EXECUTE             = 0x20019
  26. KEY_NOTIFY              = 0x10
  27. KEY_QUERY_VALUE         = 0x01
  28. KEY_SET_VALUE           = 0x02
  29. KEY_ALL_ACCESS          = 0xF003F
  30. KEY_READ                = 0x20019
  31. KEY_WRITE               = 0x20006
  32.  
  33. # Registry Data types
  34. REG_NONE                = 0    # No value type
  35. REG_SZ                  = 1    # Unico nul terminated string
  36. REG_EXPAND_SZ           = 2    # Unicode nul terminated string
  37.                                # (with environment variable references)
  38. REG_BINARY              = 3 #   // Free form binary
  39. REG_DWORD                =    4 #   // 32-bit number
  40. REG_DWORD_LITTLE_ENDIAN =   4 #   // 32-bit number (same as REG_DWORD)
  41. REG_DWORD_BIG_ENDIAN    =    5 #   // 32-bit number
  42. REG_LINK                =     6 #   // Symbolic Link (unicode)
  43. REG_MULTI_SZ            =     7 #   // Multiple Unicode strings
  44. REG_RESOURCE_LIST       =     8 #   // Resource list in the resource map
  45. REG_FULL_RESOURCE_DESCRIPTOR  = 9   # Resource list in the hardware description
  46. REG_RESOURCE_REQUIREMENTS_LIST  = 10
  47.  
  48.  
  49. class WINREGCloseKey(ImpactPacket.Header):
  50.     OP_NUM = 5
  51.  
  52.     __SIZE = 20
  53.  
  54.     def __init__(self, aBuffer = None):
  55.         ImpactPacket.Header.__init__(self, WINREGCloseKey.__SIZE)
  56.         if aBuffer: self.load_header(aBuffer)
  57.  
  58.     def get_context_handle(self):
  59.         return self.get_bytes().tolist()[:20]
  60.     def set_context_handle(self, handle):
  61.         assert 20 == len(handle)
  62.         self.get_bytes()[:20] = array.array('B', handle)
  63.  
  64.  
  65.     def get_header_size(self):
  66.         return WINREGCloseKey.__SIZE
  67.  
  68.  
  69. class WINREGRespCloseKey(ImpactPacket.Header):
  70.     __SIZE = 24
  71.  
  72.     def __init__(self, aBuffer = None):
  73.         ImpactPacket.Header.__init__(self, WINREGRespCloseKey.__SIZE)
  74.         if aBuffer: self.load_header(aBuffer)
  75.  
  76.     def get_context_handle(self):
  77.         return self.get_bytes().tolist()[:20]
  78.     def set_context_handle(self, handle):
  79.         assert 20 == len(handle)
  80.         self.get_bytes()[:20] = array.array('B', handle)
  81.  
  82.     def get_return_code(self):
  83.         return self.get_long(20, '<')
  84.     def set_return_code(self, code):
  85.         self.set_long(20, code, '<')
  86.  
  87.  
  88.     def get_header_size(self):
  89.         return WINREGRespCloseKey.__SIZE
  90.  
  91.  
  92. class WINREGDeleteValue(ImpactPacket.Header):
  93.     OP_NUM = 8
  94.  
  95.     __SIZE = 40
  96.  
  97.     def __init__(self, aBuffer = None):
  98.         ImpactPacket.Header.__init__(self, WINREGDeleteValue.__SIZE)
  99.  
  100.         # Write some unknown fluff.
  101.         self.get_bytes()[22:36] = array.array('B', '\x0a\x02\x00\xEC\xfd\x7f\x05\x01' + (6 * '\x00'))
  102.  
  103.         if aBuffer: self.load_header(aBuffer)
  104.  
  105.     def get_context_handle(self):
  106.         return self.get_bytes().tolist()[:20]
  107.     def set_context_handle(self, handle):
  108.         assert 20 == len(handle)
  109.         self.get_bytes()[:20] = array.array('B', handle)
  110.  
  111.     def get_name(self):
  112.         return unicode(self.get_bytes().tostring()[40:], 'utf-16le')
  113.     def set_name(self, name):
  114.         if not name.endswith('\0'):
  115.             name += '\0'
  116.         namelen = len(name)
  117.         wlen = 2 * namelen
  118.         if (wlen % 4):
  119.             pad = ('\x00' * (4 - (wlen % 4)))
  120.         else:
  121.             pad = ''
  122.  
  123.         self.set_word(20, 2 * namelen, '<')
  124.         self.set_long(36, namelen, '<')
  125.         self.get_bytes()[40:] = array.array('B', name.encode('utf-16le') + pad)
  126.  
  127.  
  128.     def get_header_size(self):
  129.         var_size = len(self.get_bytes()) - WINREGDeleteValue.__SIZE
  130.         assert var_size > 0
  131.         return WINREGDeleteValue.__SIZE + var_size
  132.  
  133.  
  134. class WINREGRespDeleteValue(ImpactPacket.Header):
  135.     __SIZE = 4
  136.  
  137.     def __init__(self, aBuffer = None):
  138.         ImpactPacket.Header.__init__(self, WINREGRespDeleteValue.__SIZE)
  139.         if aBuffer: self.load_header(aBuffer)
  140.  
  141.     def get_return_code(self):
  142.         return self.get_long(0, '<')
  143.     def set_return_code(self, code):
  144.         self.set_long(0, code, '<')
  145.  
  146.  
  147.     def get_header_size(self):
  148.         return WINREGRespDeleteValue.__SIZE
  149.  
  150.  
  151. class WINREGDeleteKey(ImpactPacket.Header):
  152.     OP_NUM = 7
  153.  
  154.     __SIZE = 40
  155.  
  156.     def __init__(self, aBuffer = None):
  157.         ImpactPacket.Header.__init__(self, WINREGDeleteKey.__SIZE)
  158.  
  159.         # Write some unknown fluff.
  160.         self.get_bytes()[22:36] = array.array('B', '\x0a\x02\x00\xEC\xfd\x7f\x05\x01' + (6 * '\x00'))
  161.  
  162.         if aBuffer: self.load_header(aBuffer)
  163.  
  164.     def get_context_handle(self):
  165.         return self.get_bytes().tolist()[:20]
  166.     def set_context_handle(self, handle):
  167.         assert 20 == len(handle)
  168.         self.get_bytes()[:20] = array.array('B', handle)
  169.  
  170.     def get_key_name(self):
  171.         return unicode(self.get_bytes().tostring()[40:], 'utf-16le')
  172.     def set_key_name(self, name):
  173.         if not name.endswith('\0'):
  174.             name += '\0'
  175.         namelen = len(name)
  176.         wlen = 2 * namelen
  177.         if (wlen % 4):
  178.             pad = ('\x00' * (4 - (wlen % 4)))
  179.         else:
  180.             pad = ''
  181.  
  182.         self.set_word(20, 2 * namelen, '<')
  183.         self.set_long(36, namelen, '<')
  184.         self.get_bytes()[40:] = array.array('B', name.encode('utf-16le') + pad)
  185.  
  186.  
  187.     def get_header_size(self):
  188.         var_size = len(self.get_bytes()) - WINREGDeleteKey.__SIZE
  189.         assert var_size > 0
  190.         return WINREGDeleteKey.__SIZE + var_size
  191.  
  192.  
  193. class WINREGRespDeleteKey(ImpactPacket.Header):
  194.     __SIZE = 4
  195.  
  196.     def __init__(self, aBuffer = None):
  197.         ImpactPacket.Header.__init__(self, WINREGRespDeleteKey.__SIZE)
  198.         if aBuffer: self.load_header(aBuffer)
  199.  
  200.     def get_return_code(self):
  201.         return self.get_long(0, '<')
  202.     def set_return_code(self, code):
  203.         self.set_long(0, code, '<')
  204.  
  205.  
  206.     def get_header_size(self):
  207.         return WINREGRespDeleteKey.__SIZE
  208.  
  209.  
  210. class WINREGCreateKey(ImpactPacket.Header):
  211.     OP_NUM = 6
  212.  
  213.     __SIZE = 64
  214.  
  215.     def __init__(self, aBuffer = None):
  216.         ImpactPacket.Header.__init__(self, WINREGCreateKey.__SIZE)
  217.  
  218.         # Write some unknown fluff.
  219.         self.get_bytes()[22:36] = array.array('B', '\x0a\x02\x00\xEC\xfd\x7f\x05\x01' + (6 * '\x00'))
  220.         self.get_bytes()[-24:] = array.array('B', 15 * '\x00' + '\x02' + 8 * '\x00')
  221.  
  222.         if aBuffer: self.load_header(aBuffer)
  223.  
  224.     def get_context_handle(self):
  225.         return self.get_bytes().tolist()[:20]
  226.     def set_context_handle(self, handle):
  227.         assert 20 == len(handle)
  228.         self.get_bytes()[:20] = array.array('B', handle)
  229.  
  230.     def get_key_name(self):
  231.         return unicode(self.get_bytes().tostring()[40:-24], 'utf-16le')
  232.     def set_key_name(self, name):
  233.         if not name.endswith('\0'):
  234.             name += '\0'
  235.         namelen = len(name)
  236.         wlen = 2 * namelen
  237.         if (wlen % 4):
  238.             pad = ('\x00' * (4 - (wlen % 4)))
  239.         else:
  240.             pad = ''
  241.  
  242.         self.set_word(20, 2 * namelen, '<')
  243.         self.set_long(36, namelen, '<')
  244.         self.get_bytes()[40:-24] = array.array('B', name.encode('utf-16le') + pad)
  245.  
  246.  
  247.     def get_header_size(self):
  248.         var_size = len(self.get_bytes()) - WINREGCreateKey.__SIZE
  249.         assert var_size > 0
  250.         return WINREGCreateKey.__SIZE + var_size
  251.  
  252.  
  253. class WINREGRespCreateKey(ImpactPacket.Header):
  254.     __SIZE = 28
  255.  
  256.     def __init__(self, aBuffer = None):
  257.         ImpactPacket.Header.__init__(self, WINREGRespCreateKey.__SIZE)
  258.         if aBuffer: self.load_header(aBuffer)
  259.  
  260.     def get_context_handle(self):
  261.         return self.get_bytes().tolist()[:20]
  262.     def set_context_handle(self, handle):
  263.         assert 20 == len(handle)
  264.         self.get_bytes()[:20] = array.array('B', handle)
  265.  
  266.     def get_return_code(self):
  267.         return self.get_long(24, '<')
  268.     def set_return_code(self, code):
  269.         self.set_long(24, code, '<')
  270.  
  271.  
  272.     def get_header_size(self):
  273.         return WINREGRespCreateKey.__SIZE
  274.  
  275.  
  276. #context handle
  277. # WORD LEN (counting the 0s)
  278. # DWORD LEN (in unicode, that is without counting the 0s)
  279. # KEYNAME in UNICODE
  280. # 6 bytes UNKNOWN (all 0s)
  281. # DWORD ACCESS_MASK
  282.  
  283. class WINREGOpenKey(ImpactPacket.Header):
  284.     OP_NUM = 15
  285.  
  286.     __SIZE = 44
  287.  
  288.     def __init__(self, aBuffer = None):
  289.         ImpactPacket.Header.__init__(self, WINREGOpenKey.__SIZE)
  290.  
  291.         self.set_access_mask(KEY_READ)
  292.  
  293.         # Write some unknown fluff.
  294.         self.get_bytes()[24:28] = array.array('B', '\x00\xEC\xfd\x7f')
  295.  
  296.         if aBuffer: self.load_header(aBuffer)
  297.  
  298.     def get_context_handle(self):
  299.         return self.get_bytes().tolist()[:20]
  300.     def set_context_handle(self, handle):
  301.         assert 20 == len(handle)
  302.         self.get_bytes()[:20] = array.array('B', handle)
  303.  
  304.     def get_key_name(self):
  305.         return unicode(self.get_bytes().tostring()[40:-4], 'utf-16le')
  306.     def set_key_name(self, name):
  307.         if not name.endswith('\0'):
  308.             name += '\0'
  309.         namelen = len(name)
  310.         padlen = 2 * (int((namelen + 2) / 4) * 4 + 2 - namelen)
  311.         pad = '\x00' * padlen
  312.  
  313.         self.set_word(20, 2 * namelen, '<')
  314.         self.set_word(22, 2 * namelen, '<')
  315.         self.set_long(28, namelen, '<')
  316.         self.set_long(36, namelen, '<')
  317.         self.get_bytes()[40:-4] = array.array('B', name.encode('utf-16le') + pad)
  318.  
  319.     def get_access_mask(self):
  320.         return self.get_long(-4, '<')
  321.     def set_access_mask(self, mask):
  322.         self.set_long(-4, mask, '<')
  323.  
  324.  
  325.     def get_header_size(self):
  326.         var_size = len(self.get_bytes()) - WINREGOpenKey.__SIZE
  327.         assert var_size > 0
  328.         return WINREGOpenKey.__SIZE + var_size
  329.  
  330.  
  331. class WINREGRespOpenKey(ImpactPacket.Header):
  332.     __SIZE = 24
  333.  
  334.     def __init__(self, aBuffer = None):
  335.         ImpactPacket.Header.__init__(self, WINREGRespOpenKey.__SIZE)
  336.         if aBuffer: self.load_header(aBuffer)
  337.  
  338.     def get_context_handle(self):
  339.         return self.get_bytes().tolist()[:20]
  340.     def set_context_handle(self, handle):
  341.         assert 20 == len(handle)
  342.         self.get_bytes()[:20] = array.array('B', handle)
  343.  
  344.     def get_return_code(self):
  345.         return self.get_long(20, '<')
  346.     def set_return_code(self, code):
  347.         self.set_long(20, code, '<')
  348.  
  349.  
  350.     def get_header_size(self):
  351.         return WINREGRespOpenKey.__SIZE
  352.  
  353.  
  354. class WINREGSetValue(ImpactPacket.Header):
  355.     OP_NUM = 22
  356.  
  357.     __SIZE = 52
  358.  
  359.     def __init__(self, aBuffer = None):
  360.         ImpactPacket.Header.__init__(self, WINREGSetValue.__SIZE)
  361.  
  362.         # Write some unknown fluff.
  363.         self.get_bytes()[24:28] = array.array('B', '\x00\xEC\xfd\x7f')
  364.         self.namelen = 0
  365.  
  366.         if aBuffer: self.load_header(aBuffer)
  367.  
  368.     def get_context_handle(self):
  369.         return self.get_bytes().tolist()[:20]
  370.     def set_context_handle(self, handle):
  371.         assert 20 == len(handle)
  372.         self.get_bytes()[:20] = array.array('B', handle)
  373.  
  374.     def get_name(self):
  375.         return unicode(self.get_bytes().tostring()[40:40+self.namelen], 'utf-16le')
  376.     def set_name(self, name):
  377.         if not name.endswith('\0'):
  378.             name += '\0'
  379.         namelen = len(name)
  380.         if namelen & 0x01:
  381.             pad = '\x00\x00'
  382.         else:
  383.             pad = ''
  384.  
  385.         self.set_word(20, 2 * namelen, '<')
  386.         self.set_word(22, 2 * namelen, '<')
  387.         self.set_long(28, namelen, '<')
  388.         self.set_long(36, namelen, '<')
  389.         padded_name = array.array('B', name.encode('utf-16le') + pad)
  390.         self.get_bytes()[40:40+self.namelen] = padded_name
  391.         self.namelen = len(padded_name)
  392.  
  393.     def get_data_type(self):
  394.         return self.get_long(40+self.namelen, '<')
  395.     def set_data_type(self, type):
  396.         self.set_long(40+self.namelen, type, '<')
  397.  
  398.     def get_data(self):
  399.         data_type = self.get_data_type()
  400.         data = self.get_bytes().tostring()[40+self.namelen+8:-4]
  401.         if data_type == REG_DWORD:
  402.             data = struct.unpack('<L', data)[0]
  403.         elif data_type == REG_SZ:
  404.             data = unicode(data, 'utf-16le')
  405.         return data
  406.  
  407.     def set_data(self, data):
  408.         data_type = self.get_data_type()
  409.         pad = ''
  410.         if data_type == REG_DWORD:
  411.             data = struct.pack('<L', data)
  412.         elif data_type == REG_SZ:
  413.             if not data.endswith('\0'):
  414.                 data += '\0'
  415.             if len(data) & 0x01:
  416.                 pad = '\x00\x00'
  417.             data = data.encode('utf-16le')
  418.         elif data_type == REG_BINARY:
  419.             if len(data) & 0x01:
  420.                 pad = '\x00\x00'
  421.  
  422.         datalen = len(data)
  423.         self.set_long(40+self.namelen+4, datalen, '<')
  424.         self.set_long(-4, datalen, '<')
  425.         self.get_bytes()[40+self.namelen+8:-4] = array.array('B', data + pad)
  426.  
  427.  
  428.     def get_header_size(self):
  429.         var_size = len(self.get_bytes()) - WINREGSetValue.__SIZE
  430.         assert var_size > 0
  431.         return WINREGSetValue.__SIZE + var_size
  432.  
  433.  
  434. class WINREGRespSetValue(ImpactPacket.Header):
  435.     __SIZE = 4
  436.  
  437.     def __init__(self, aBuffer = None):
  438.         ImpactPacket.Header.__init__(self, WINREGRespSetValue.__SIZE)
  439.         if aBuffer: self.load_header(aBuffer)
  440.  
  441.     def get_return_code(self):
  442.         return self.get_long(0, '<')
  443.     def set_return_code(self, code):
  444.         self.set_long(0, code, '<')
  445.  
  446.  
  447.     def get_header_size(self):
  448.         return WINREGRespSetValue.__SIZE
  449.  
  450.  
  451. # context_handle
  452. # len
  453. # \x0a\x02\x00\xec\xfd\x7f\x05\x01 \x00 * 6
  454. # len /2
  455. # valuename
  456.  
  457. class WINREGQueryValue(ImpactPacket.Header):
  458.     OP_NUM = 17
  459.  
  460.     __SIZE = 80
  461.  
  462.     def __init__(self, aBuffer = None):
  463.         ImpactPacket.Header.__init__(self, WINREGQueryValue.__SIZE)
  464.  
  465.         self.set_data_len(0xC8)
  466.  
  467.         # Write some unknown fluff.
  468.         self.get_bytes()[24:28] = array.array('B', '\x00\xEC\xfd\x7f')
  469.         self.get_bytes()[-40:-28] = array.array('B', '\x8c\xfe\x12\x00\x69\x45\x13\x00\x69\x45\x13\x00')
  470.         self.get_bytes()[-16:-12] = array.array('B', '\x94\xfe\x12\x00')
  471.         self.get_bytes()[-8:-4] = array.array('B', '\x80\xfe\x12\x00')
  472.  
  473.         if aBuffer: self.load_header(aBuffer)
  474.  
  475.     def get_context_handle(self):
  476.         return self.get_bytes().tolist()[:20]
  477.     def set_context_handle(self, handle):
  478.         assert 20 == len(handle)
  479.         self.get_bytes()[:20] = array.array('B', handle)
  480.  
  481.     def get_name(self):
  482.         return unicode(self.get_bytes().tostring()[40:-40], 'utf-16le')
  483.     def set_name(self, name):
  484.         if not name.endswith('\0'):
  485.             name += '\0'
  486.         namelen = len(name)
  487.         if namelen & 0x01:
  488.             pad = '\x00\x00'
  489.         else:
  490.             pad = ''
  491.  
  492.         self.set_word(20, 2 * namelen, '<')
  493.         self.set_word(22, 2 * namelen, '<')
  494.         self.set_long(28, namelen, '<')
  495.         self.set_long(36, namelen, '<')
  496.         self.get_bytes()[40:-40] = array.array('B', name.encode('utf-16le') + pad)
  497.  
  498.     def get_data_len(self):
  499.         return self.get_long(-28, '<')
  500.     def set_data_len(self, len):
  501.         self.set_long(-28, len, '<')
  502.         self.set_long(-12, len, '<')
  503.  
  504.  
  505.     def get_header_size(self):
  506.         var_size = len(self.get_bytes()) - WINREGQueryValue.__SIZE
  507.         assert var_size > 0
  508.         return WINREGQueryValue.__SIZE + var_size
  509.  
  510.  
  511. class WINREGRespQueryValue(ImpactPacket.Header):
  512.     __SIZE = 44
  513.  
  514.     def __init__(self, aBuffer = None):
  515.         ImpactPacket.Header.__init__(self, WINREGRespQueryValue.__SIZE)
  516.         if aBuffer: self.load_header(aBuffer)
  517.  
  518.     def get_data_type(self):
  519.         return self.get_long(4, '<')
  520.     def set_data_type(self, type):
  521.         self.set_long(4, type, '<')
  522.  
  523.     def get_data_len(self):
  524.         return self.get_long(20, '<')
  525.     def set_data_len(self, len):
  526.         self.set_long(20, len, '<')
  527.         self.set_long(28, len, '<')
  528.  
  529.     def get_data(self):
  530.         data_type = self.get_data_type()
  531.         data = self.get_bytes().tostring()[24:24+self.get_data_len()]
  532.         if data_type == REG_DWORD:
  533.             data = struct.unpack('<L', data)[0]
  534.         elif data_type == REG_SZ:
  535.             data = unicode(data, 'utf-16le')
  536.  
  537.         return data
  538.  
  539.     def set_data(self, len):
  540.         raise Exception, "method not implemented"
  541.  
  542.     def get_return_code(self):
  543.         return self.get_long(-4, '<')
  544.     def set_return_code(self, code):
  545.         self.set_long(-4, code, '<')
  546.  
  547.  
  548.     def get_header_size(self):
  549.         var_size = len(self.get_bytes()) - WINREGRespQueryValue.__SIZE
  550.         assert var_size > 0
  551.         return WINREGRespQueryValue.__SIZE + var_size
  552.  
  553.  
  554. class WINREGOpenHK(ImpactPacket.Header):
  555.     # OP_NUM is a "virtual" field.
  556.  
  557.     __SIZE = 12
  558.  
  559.     def __init__(self, aBuffer = None):
  560.         ImpactPacket.Header.__init__(self, WINREGOpenHK.__SIZE)
  561.  
  562.         self.set_long(0, 0x06f7c0, '<') # magic, apparently always the same
  563.         self.set_long(4, 0x019b58, '<') # don't know exactly, can be almost anything so far
  564.         self.set_access_mask(0x2000000)
  565.  
  566.         if aBuffer: self.load_header(aBuffer)
  567.  
  568.     def get_access_mask(self):
  569.         return self.get_long(8, '<')
  570.     def set_access_mask(self, mask):
  571.         self.set_long(8, mask, '<')
  572.  
  573.  
  574.     def get_header_size(self):
  575.         return WINREGOpenHK.__SIZE
  576.  
  577.  
  578. class WINREGRespOpenHK(ImpactPacket.Header):
  579.     __SIZE = 24
  580.  
  581.     def __init__(self, aBuffer = None):
  582.         ImpactPacket.Header.__init__(self, WINREGRespOpenHK.__SIZE)
  583.         if aBuffer: self.load_header(aBuffer)
  584.  
  585.     def get_context_handle(self):
  586.         return self.get_bytes().tolist()[:20]
  587.     def set_context_handle(self, handle):
  588.         assert 20 == len(handle)
  589.         self.get_bytes()[:20] = array.array('B', handle)
  590.  
  591.     def get_return_code(self):
  592.         return self.get_long(20, '<')
  593.     def set_return_code(self, code):
  594.         self.set_long(20, code, '<')
  595.  
  596.  
  597.     def get_header_size(self):
  598.         return WINREGRespOpenHK.__SIZE
  599.  
  600.  
  601. class WINREGOpenHKCR(WINREGOpenHK):
  602.     OP_NUM = 0
  603.  
  604. class WINREGOpenHKLM(WINREGOpenHK):
  605.     OP_NUM = 2
  606.  
  607. class WINREGOpenHKU(WINREGOpenHK):
  608.     OP_NUM = 4
  609.  
  610.  
  611. class DCERPCWinReg:
  612.     def __init__(self, dce):
  613.         self._dce = dce
  614.  
  615.     def openHKCR(self):
  616.         winregopen = WINREGOpenHKCR()
  617.         self._dce.send(winregopen)
  618.         data = self._dce.recv()
  619.         retVal = WINREGRespOpenHK(data)
  620.         return retVal
  621.  
  622.     def openHKU(self):
  623.         winregopen = WINREGOpenHKU()
  624.         self._dce.send(winregopen)
  625.         data = self._dce.recv()
  626.         retVal = WINREGRespOpenHK(data)
  627.         return retVal
  628.  
  629.     def regCloseKey(self, context_handle):
  630.         wreg_closekey = WINREGCloseKey()
  631.         wreg_closekey.set_context_handle( context_handle )
  632.         self._dce.send(wreg_closekey)
  633.         data = self._dce.recv()
  634.         retVal = WINREGRespCloseKey(data)
  635.         return retVal
  636.  
  637.     def regOpenKey(self, context_handle, aKeyname, anAccessMask):
  638.         wreg_openkey = WINREGOpenKey()
  639.         wreg_openkey.set_context_handle( context_handle )
  640.         wreg_openkey.set_key_name( aKeyname )
  641.         wreg_openkey.set_access_mask( anAccessMask )
  642.         self._dce.send(wreg_openkey)
  643.         data = self._dce.recv()
  644.         retVal = WINREGRespOpenKey(data)
  645.         return retVal
  646.  
  647.     def regCreateKey(self, context_handle, aKeyname):
  648.         wreg_createkey = WINREGCreateKey()
  649.         wreg_createkey.set_context_handle( context_handle )
  650.         wreg_createkey.set_key_name( aKeyname )
  651.         self._dce.send(wreg_createkey)
  652.         data = self._dce.recv()
  653.         retVal = WINREGRespCreateKey(data)
  654.         return retVal
  655.  
  656.     def regDeleteKey(self, context_handle, aKeyname):
  657.         wreg_deletekey = WINREGDeleteKey()
  658.         wreg_deletekey.set_context_handle( context_handle )
  659.         wreg_deletekey.set_key_name( aKeyname )
  660.         self._dce.send(wreg_deletekey)
  661.         data = self._dce.recv()
  662.         retVal = WINREGRespDeleteKey(data)
  663.         return retVal
  664.  
  665.     def regDeleteValue(self, context_handle, aValuename):
  666.         wreg_deletevalue = WINREGDeleteValue()
  667.         wreg_deletevalue.set_context_handle( context_handle )
  668.         wreg_deletevalue.set_name( aValuename )
  669.         self._dce.send(wreg_deletevalue)
  670.         data = self._dce.recv()
  671.         retVal = WINREGRespDeleteValue(data)
  672.         return retVal
  673.  
  674.     def regQueryValue(self, context_handle, aValueName, aDataLen):
  675.         wreg_queryval = WINREGQueryValue()
  676.         wreg_queryval.set_context_handle( context_handle )
  677.         wreg_queryval.set_name( aValueName )
  678.         wreg_queryval.set_data_len( aDataLen )
  679.         self._dce.send(wreg_queryval)
  680.         data = self._dce.recv()
  681.         retVal = WINREGRespQueryValue(data)
  682.         return retVal
  683.  
  684.     def regSetValue(self, context_handle, aValueType, aValueName, aData):
  685.         wreg_setval = WINREGSetValue()
  686.         wreg_setval.set_context_handle( context_handle )
  687.         wreg_setval.set_data_type(aValueType)
  688.         wreg_setval.set_name(aValueName)
  689.         wreg_setval.set_data(aData)
  690.         self._dce.send(wreg_setval)
  691.         data = self._dce.recv()
  692.         retVal = WINREGRespSetValue(data)
  693.         return retVal
  694.  
  695.     def openHKLM(self):
  696.         winregopen = WINREGOpenHKLM()
  697.         self._dce.send(winregopen)
  698.         data = self._dce.recv()
  699.         retVal = WINREGRespOpenHK(data)
  700.         return retVal
  701.  
  702.